Unidad 1. El Lenguaje Java y un poquito de Dart

1. El lenguaje Java

Java es un lenguaje de programación de propósito general, concurrente y orientado a objetos que fue diseñado específicamente para tener tan pocas dependencias de implementación como fuera posible. Su objetivo es permitir que los desarrolladores de aplicaciones escriban el programa una vez y lo ejecuten en cualquier dispositivo (conocido en inglés como WORA, o "write once, run anywhere"), lo que quiere decir que el código puede escribirse una sola vez y ser ejecutado en cualquier tipo de dispositivos (PC, móvil, etc.).

Las características de Java son:

• Sencillo: Es un lenguaje sencillo de aprender.

• Orientado a Objetos: Posiblemente sea el lenguaje más orientado a objetos de todos los existentes; en Java, a excepción de los tipos fundamentales de variables (int, char, long…), todo es un objeto.

• Distribuido: Java está muy orientado al trabajo en red, soportando protocolos como TCP/IP, UDP, HTTP y FTP. Por otro lado el uso de estos protocolos es bastante sencillo comparándolo con otros lenguajes que los soportan.

• Robusto: El compilador Java detecta muchos errores que otros compiladores solo detectarían en tiempo de ejecución o incluso nunca.

• Seguro: Sobre todo un tipo de desarrollo: los Applet. Estos son programas diseñados para ser ejecutados en una página web.

• Portable: En Java no hay aspectos dependientes de la implementación, todas las implementaciones de Java siguen los mismos estándares en cuanto a tamaño y almacenamiento de los datos.

• Arquitectura Neutral: El código generado por el compilador Java es independiente de la arquitectura: podría ejecutarse en un entorno UNIX, Mac, Windows, Móvil, etc.

• Rendimiento medio: Actualmente la velocidad de procesado del código Java es semejante a las de otros lenguajes orientados a objetos.

• Multithread: Soporta de modo nativo los threads (hilos de ejecución), sin necesidad del uso de de librerías específicas.

1.1 Primer ejemplo

La aplicación más pequeña posible es la que simplemente imprime un mensaje en la pantalla.

Tradicionalmente, el mensaje suele ser "Hola Mundo!". Esto es justamente lo que hace el siguiente fragmento de código:

​x
public class Main {

    public static void main(String[] args) {        
        System.out.println("Hola Mundo");
    }
}

Hay que ver en detalle la aplicación anterior, línea a línea. Esas líneas de código contienen los componentes mínimos para imprimir Hola Mundo! en la pantalla. Es un ejemplo muy simple, que no instancia objetos de ninguna otra clase; sin embargo, accede a otra clase incluida en el JDK.

public class Main

Esta línea declara la clase Main. El nombre de la clase especificado en el fichero fuente se utiliza para crear un fichero nombredeclase.class en el directorio en el que se compila la aplicación. En este caso, el compilador creará un fichero llamado Main.class.

public static void main( String args[] )

Esta línea especifica un método que el intérprete Java busca para ejecutar en primer lugar. Igual que en otros lenguajes, Java utiliza una palabra clave main para especificar la primera función a ejecutar. En este ejemplo tan simple no se pasan argumentos.

• public significa que el método main() puede ser llamado por cualquiera, incluyendo el intérprete Java.

• static es una palabra clave que le dice al compilador que main se refiere a la propia clase HolaMundo y no a ninguna instancia de la clase. De esta forma, si alguien intenta hacer otra instancia de la clase, el método main() no se instanciaría.

• void indica que main() no devuelve nada. Esto es importante ya que Java realiza una estricta comprobación de tipos, incluyendo los tipos que se ha declarado que devuelven los métodos.

• args[] es la declaración de un array de Strings. Estos son los argumentos escritos tras el nombre de la clase en la línea de comandos: java Main arg1 arg2 …

System.out.println( "Hola Mundo!" );

Esta es la funcionalidad de la aplicación. Esta línea muestra el uso de un nombre de clase y método. Se usa el método println() de la clase out que está en el paquete System. El método println() toma una cadena como argumento y la escribe en el stream de salida estándar; en este caso, la ventana donde se lanza la aplicación. La clase PrintStream tiene un método instanciable llamado println(), que lo que hace es presentar en la salida estándar del Sistema el argumento que se le pase. En este caso, se utiliza la variable o instancia de out para acceder al método. El resultado sería el siguiente:

En el caso que no tengamos el IDE todavía instalado, podemos hacer usar el siguiente compilador online: https://replit.com/

Dentro de este podréis tener en la capa básica 44 proyectos o replit gratuitos.

1.2 Elementos básicos

1.2.1 Comentarios

En Java hay tres tipos de comentarios:

Los dos primeros tipos de comentarios son los que todo programador conoce y se utilizan del mismo modo.

Los comentarios de documentación, colocados inmediatamente antes de una declaración (de variable o función), indican que ese comentario ha de ser colocado en la documentación que se genera automáticamente cuando se utiliza la herramienta de Java, javadoc, no disponible en otros lenguajes de programación. Este tipo de comentario lo veremos más adelante.

1.2.2 Identificadores

Los identificadores nombran variables, funciones, clases y objetos; cualquier cosa que el programador necesite identificar o usar.

Reglas para la creación de identificadores:

• Java hace distinción entre mayúsculas y minúsculas, por lo tanto, nombres o identificadores como var1, Var1 y VAR1 son distintos.

• Pueden estar formados por cualquiera de los caracteres del código Unicode, por lo tanto, se pueden declarar variables con el nombre: añoDeCreación, raïm, etc., aunque eso sí, el primer carácter no puede ser un dígito numérico y no pueden utilizarse espacios en blanco ni símbolos coincidentes con operadores.

• La longitud máxima de los identificadores es prácticamente ilimitada.

• No puede ser una palabra reservada del lenguaje ni los valores lógicos true o false.

• No pueden ser iguales a otro identificador declarado en el mismo ámbito.

• IMPORTANTE: Por convenio:

  • Los nombres de las variables y los métodos deberían empezar por una letra minúscula y los de las clases por mayúscula.

  • Si el identificador está formado por varias palabras, la primera se escribe en minúsculas (excepto para las clases) y el resto de palabras se hace empezar por mayúscula (por ejemplo: añoDeCreación).

  • Estas reglas no son obligatorias, pero son convenientes ya que ayudan al proceso de codificación de un programa, así como a su legibilidad. Es más sencillo distinguir entre clases y métodos o variables.

     

Serían identificadores válidos, por ejemplo:

• contador

• suma

• edad

• sueldoBruto

• sueldoNeto

• nombre_usuario

• nombre_Completo

• letraDni

y su uso sería, por ejemplo:

int contador; // crea variable de tipo int llamada contador

float sueldoNeto; // crea variable de tipo float llamada sueldoNeto

char letraDni; // crea variable de tipo char llamada letraDni

1.3 Tipos de datos

En Java existen dos tipos principales de datos:

• Tipos de datos simples: Nos permiten crear variables que almacenan un solo valor. Por ejemplo para un contador, edad, precio, etc. Son los que más vamos a utilizar por ahora.

• Tipos de datos compuestos: Estructuras de datos más complejas que permiten almacenar muchos datos (vectores, objetos, etc.). Las veremos en futuras unidades.

Tipos de datos simples soportados por Java:

• Para números enteros: byte, short, int, long

• Para números reales: float, double

• Para números reales: float, double

• Para valores lógicos: boolean.

⚠ Java no realiza una comprobación de los rangos.

Por ejemplo: si a una variable de tipo short con el valor 32.767 se le suma 1, sorprendentemente el resultado será -32.768 (no produce un error de tipo desbordamiento como en otros lenguajes de programación, sino que se comporta de forma cíclica).

Existe un tipo de dato compuesto llamado String que conviene conocer ya que permite representar texto. Más adelante veremos cómo se utiliza.

1.4 Declaración de variables

La forma básica de declarar (crear) una variable es la siguiente:

tipo identificador;

Por ejemplo, creamos una variable de tipo int llamada edad:

int edad;

Las variables pueden ser inicializadas en el momento de su declaración, es decir, se les puede dar un valor inicial al crearlas. Por ejemplo, creamos una variable de tipo int llamada edad y le asignamos 25 como valor inicial:

int edad = 25;

Esto es equivalente a primero declararla y luego asignarle el valor:

int edad; ​ edad = 25;

También es posible declarar varias variables en una sola línea. Por ejemplo, creamos tres variables de tipo float llamadas precio1, precio2 y precio3:

float precio1f, precio2f, precio3f;

Esto es equivalente a:

float precio1f;

float precio2f;

float precio3f;

A su vez, también pueden inicializarse. Por ejemplo:

float precio1 = 7.0f, precio2 = 7.25f, precio3 = 0.5f;

Esto es equivalente a:

float precio1 = 7.0f;

float precio2 = 7.25f;

float precio3 = 0.5f;

Las constantes reales o en coma flotante se expresan con coma decimal y opcionalmente seguidos de un exponente. El valor puede finalizarse con una f o una F para indica el formato float (por defecto es double). Por ejemplo:

float f1 = 13.5;

Esto nos daría error puesto que la variable f1 es de tipo float mientras que 13.5 es double. Es necesario ponerle a 13.5 la f al final para indicar que es float.

Otros ejemplos a la hora de definir valores:

xxxxxxxxxx
double a = 15.2; // de tipo double
double b = 15.2D; // el mismo valor
double c = 1.52e1; // el mismo valor
double d = 0.152E2; // el mismo valor
double e = .8e10; // de tipo double
float f = 15.8f; // de tipo float
float g = 15.8F; // tambien de tipo float

Como se verá más adelante cada tipo de dato primitivo tiene una clase correspondiente (Boolean, Character, Byte, Short, Integer, Long, Float y Double), llamadas wrappers, que definen también constantes y métodos útiles.

En resumen la declaración de variables sigue el siguiente patrón:

🎓tipo identificador [ = valor][,identificador [= valor] ...];

Es decir, es obligatorio indicar el tipo y el identificador (además de terminar en punto y coma como todas las instrucciones). Opcionalmente (indicado entre corchetes) se puede inicializar y/o se pueden declarar más variables.

⚠ Si una variable no ha sido inicializada, Java le asigna un valor por defecto.

Este valor es:

• Para las variables de tipo numérico, el valor por defecto es cero ( 0 ),.

• Las variables de tipo char, el valor ''\u0000''.

• Las variables de tipo boolean, el valor false.

• Para las variables de tipo referencial (objetos), el valor null.

Es una buena práctica inicializar siempre todas las variables.

Palabras clave

Palabras reservadas

Además, el lenguaje se reserva unas cuantas palabras más, pero que hasta ahora no tienen un cometido específico. Son:

1.4.1 Ámbito de una variable

🎓 El ámbito de una variable es la porción del programa donde dicha variable puede utilizarse.

El ámbito de una variable depende del lugar del programa donde es declarada, pudiendo pertenecer a cinco categorías distintas.

1. Variable global.

2. Variable local.

3. Atributo.

4. Parámetro de un método.

5. Parámetro de un tratador de excepciones.

Por ahora utilizaremos solo variables locales nunca variables globales. Las demás categorías las veremos en posteriores unidades.

1.4.2 Variables locales

🎓 Una variable local se declara dentro del cuerpo de un método de una clase y es visible únicamente dentro de dicho método.

Se puede declarar en cualquier lugar del cuerpo, incluso después de instrucciones ejecutables, aunque es una buena costumbre declararlas justo al principio.

También pueden declararse variables dentro de un bloque con llaves {...}. En ese caso, sólo serán “visibles” dentro de dicho bloque.

Por ejemplo (No es necesario entender lo que hace el programa) :

xxxxxxxxxx
    public static void main(String[] args) {
        // TODO code application logic here
        int i;
        for (i=0;i<10;i++)
            System.out.println("El valor de i es: "+i);
    }
}

En este ejemplo existe una variable local: int i; únicamente puede utilizarse dentro del bloque main donde fué creada.

1.4.3 Constantes (final)

Al declarar una variable puede utilizarse la palabra reservada final para indicar que el valor de la variable no podrá modificarse (es una constante).

Por ejemplo, creamos variable constante tipo int llamada x con valor 18:

final int x = 18;

Por ejemplo, creamos variable constante tipo float llamada pi con valor 3.14:

final float pi = 3.14;

Si posteriormente intentamos modificar sus valores se producirá un error y Java nos avisará de que no es posible.

x = 20; // no permitido, produce error ​ pi = 7; // no permitido, produce error

⚠ Por lo tanto una variable precedida de la palabra final se convierte en una constante. O lo que es lo mismo, para definir una constante en Java deberemos preceder su declaración de la palabra reservada final.

1.5 Operadores

Los operadores son una parte indispensable de la programación ya que nos permiten realizar cálculos matemáticos y lógicos, entre otras cosas. Los operadores pueden ser:

Aritméticos : sumas, restas, etc.

Relacionales : menor, menor o igual, mayor, mayor o igual, etc.

Lógicos : and, or, not, etc.

Bits : prácticamente no los utilizaremos en este curso.

Asignación : =

1.5.1 Aritméticos

El operador - puede utilizarse en su versión unaria ( - op1 ) y la operación que realiza es la de invertir el signo del operando.

Los operadores ++ y -- realizan un incremento y un decremento unitario respectivamente. Es decir:

x++ equivale a x = x + 1

x-- equivale a x = x - 1

Los operadores ++ y -- admiten notación postfija y prefija:

• op1++: Primero se ejecuta la instrucción en la cual está inmerso y después se incrementa op1.

• op1--: Primero se ejecuta la instrucción en la cual está inmerso y después se decrementa op1.

• ++op1: Primero se incrementa op1 y después ejecuta la instrucción en la cual está inmerso.

• --op1: Primero se decrementa op1 y después ejecuta la instrucción en la cual está inmerso.

Los operadores incrementales suelen utilizarse a menudo en los bucles (estructuras repetitivas). Lo veremos más adelante.

1.5.2 Relacionales

Los operadores relacionales actúan sobre valores enteros, reales y caracteres (char); y devuelven un valor del tipo boolean (true o false).

Ejemplo:

xxxxxxxxxx
public static void main(String[] args) {
        double op1, op2;
        char op3, op4;
        op1=1.34;
        op2=1.35;
        op3='a';
        op4='b';
        
        System.out.println("op1="+ op1 +" ope2="+ op2);
        System.out.println("op1>op2=" + (op1 > op2));
        System.out.println("op1<op2=" + (op1 < op2));
        System.out.println("op1==op2=" + (op1 == op2));
        System.out.println("op1!=op2=" + (op1 != op2));
        System.out.println("'a'>'b'=" + (op3 > op4));    
    }

Resultado de ejecución:

1.5.3 Lógicos

Estos operadores actúan sobre operadores o expresiones lógicas, es decir, aquellos que se evalúan a cierto o falso (true / false).

xxxxxxxxxx
    public static void main(String[] args) {
       boolean a, b, c, d;
  
       a=true;
       b=true;
       c=false;
       d=false;
       
       System.out.println("true Y true =" +  (a && b));
       System.out.println("true Y false =" +  (a && c));
       System.out.println("false Y false =" +  (c && d));
       System.out.println("true O true =" +  (a || b));
       System.out.println("true O false =" +  (a || c));
       System.out.println("false O false =" +  (c || d));
       System.out.println("No true =" +  !a);
       System.out.println("No false =" +  !c);
       System.out.println("(3 > 4) Y true = " + ((3>4) && a));
        
    }

Resultado de ejecución:

1.5.4 Asignación

El operador de asignación es el símbolo igual: =

variable = expresión

Es posible combinar el operador de asignación con otros operadores para, de forma abreviada, realizar un cálculo y asignarlo a una variable:

1.5.5 Expresiones

Una expresión es la combinación de varios operadores y operandos. Por ejemplo, tenemos las siguientes expresiones:

7 + 5 * 4 - 2 ​ 10 + (1 % 5) ​ (7 * x) <= N ​ etc.

El lenguaje Java evalúa las expresiones aplicando los operadores uno a uno siguiendo un orden específico. Este orden se detalla en el siguiente punto.

1.5.6 Precedencia de operadores

Indica el orden en el que se evalúan los operadores en una expresión. No es necesario saberse toda la lista de memoria, pero es importante conocer al menos los más utilizados: matemáticos, relacionales, lógicos y de asignación.

Algunos de estos operadores los veremos en unidades posteriores, ahora mismo no es necesario que sepas qué hacen.

1. Operadores postfijos: [ ] . (paréntesis)

2. Operadores unarios: ++expr, --expr, -expr, ~ !

3. Creación o conversión de tipo: new (tipo)expr

4. Multiplicación y división: *, /, %

5. Suma y resta: +, -

6. Desplazamiento de bits: <<, >>, >>>

7. Relacionales: <, >, <=, >=

8. Igualdad y desigualdad: ==, !=

9. AND a nivel de bits: &

10. AND lógico: &&

11. XOR a nivel de bits: ^

12. OR a nivel de bits: |

13. OR lógico: ||

14. Operador condicional: ? :

15. Asignación: =, +=, -=, *=, /=, %=, ^=, &=, |=, >>=, <<=

1.6 Conversión de tipos

1.6.1 Casting

La conversión entre tipos primitivos se realiza mediante el casting. Java proporciona dos tipos de casting: implícito y explícito. El implícito se realiza automáticamente, mientras que el explícito la tenemos que escribir nosotros.

Casting implícito

El compilador realiza automáticamente el casting implícito cuando el tipo al que se ha de convertir un dato es más amplio que el tipo original.

Es decir, Java hará el casting implícito automáticamente cuando convertimos:

• de char a int o de char a float

• de int a float

Por ejemplo:

xxxxxxxxxx
float foo = 'a';   // convertimos el char 'a' a float. El valor de foo sera 97.0f

int bar = 'a';     // convertimos el char 'a' a int. EL valor de bar sera 97

float baz = 97;    // convertimos el int 97 a float. El valor de baz sera 97.0f

Si tratamos de hacer un casting implícito al revés, el compilador nos dará un error:

xxxxxxxxxx
char bar = 65633;   // error, casting implícito de int a char no permitido

char baz = 97f;   // error, casting implícito de float a char no permitido

int qux = 97f;    // error, casting implícito de float a int no permitido

⚠ El casting con los tipos boolean y String no se puede realizar.

Casting explicito

Hemos visto que el casting implícito no se puede realizar cuando queremos convertir a un tipo más estrecho (por ejemplo, convertir de float a int, ya que se pierden los decimales). Pero a veces necesitamos hacerlo, sabiendo que vamos a perder precisión. En este caso tenemos que explicitar el casting.

Para realizar un casting explícito, se debe escribir el tipo al que se quiere convertir entre paréntesis, justo antes del valor que se quiere convertir.

(tipo) valor

Los siguientes ejemplos ilustran el uso del casting explícito:

xxxxxxxxxx
// de int a char
char bar = (char) 65633;   // bar es 97 (el valor máximo de char es 65535)

// de float a char
char baz = (char) 97.53f;  // baz es 97, se pierden los decimales

// de float a int
int quux = (int) 14.67565f;  // quux es 14, se pierden los decimales

xxxxxxxxxx
// de int a char
int fooa = 65633;
char bar = (char) fooa;   // bar es 97, el valor máximo de char es 65535

// de float a char
float foob = 97.53f;
char baz = (char) foob;  // baz es 97, se pierden los decimales

// de float a int
float fooc = 14.67565f;
int quux = (int) fooc;  // quux es 14, se pierden los decimales

xxxxxxxxxx
float foo = 5 / 2;          // foo es 2.0f

float bar = (float) 5 / 2;  // bar es 2.5f

1.6.2 Conversión textual

Además de las conversiones con casting, Java incorpora una serie de métodos para hacer otras conversiones.

Concatenación

Se puede convertir cualquier valor en un String sólo concatenando con un String vacío "".

xxxxxxxxxx
String foo = "" + 'a';    // foo es "a"
String bar = "" + 865;    // bar es "865"
String baz = "" + 23.78f; // baz es "23.78"
String quux = "" + true;  // quux es "true"

String.valueOf()

De forma equivalente a la concatenación, se puede utilizar el método String.valueOf () para convertir a String.

xxxxxxxxxx
String foo = String.valueOf('a');    // foo es "a"
String bar = String.valueOf(865);    // bar es "865"
String baz = String.valueOf(23.78f); // baz es "23.78"
String quux = String.valueOf(true);  // quux es "true"

charAt()

Lógicamente, no podemos convertir un String en un char, ya que el String puede tener varios caracteres. Pero podemos usar el método Char () para obtener un caracter que esté en una determinada posición.

xxxxxxxxxx
char foo = "java8".charAt(0);  // foo es 'j'
char baz = "java8".charAt(4);  // baz es '8'

Hay que tener en cuenta que las posiciones empiezan por 0.

Character.getNumericValue()

En el punto anterior hemos visto que si hacemos el casting implícito para convertir un char en un int, obtenemos el valor Unicode del carácter.

Si queremos obtener el valor que representa el caracter se puede hacer con el método Character.getNumericValue ().

xxxxxxxxxx
char foo = '9';

int bar = foo; // bar se 57, con el casting obtenemos el valor unicode

int baz = Character.getNumericValue(foo); // baz se 9, obtenemos el valor representado por el caracter

parseInt() y parseFloat()

Para obtener el valor numérico representado por un String podemos utilizar parseInt () o parseFloat ().

xxxxxxxxxx
String foo = "213";

int bar = Integer.parseInt(foo);  // bar es 213

xxxxxxxxxx
String foo = "23.78";

float bar = Float.parseFloat(foo);  // bar es 23.78f

1.7 La clase Math

Se echan de menos operadores matemáticos más potentes en Java. Por ello se ha incluido una clase especial llamada Math dentro del paquete java.lang.

Esta clase posee muchos métodos muy interesantes para realizar cálculos matemáticos complejos como cálculo de potencias, raíces cuadradas, valores absolutos, seno, coseno, etc.

Por ejemplo:

xxxxxxxxxx
double x = Math.pow(3,3);    // Potencia 3 ^ 3

double y = Math.sqrt(9);    // Raíz cuadrada de 9

También posee constantes como:

xxxxxxxxxx
double PI -> El número Π (3,14159265…)

double E -> El número e (2, 7182818245...)

Algunos ejemplos de otros métodos:

1.8 Literales

A la hora de tratar con valores de los tipos de datos simples (y Strings) se utiliza lo que se denomina “literales”. Los literales son elementos que sirven para representar un valor en el código fuente del programa.

En Java existen literales para los siguientes tipos de datos:

• Lógicos (boolean).

• Carácter (char).

• Enteros (byte, short, int y long).

• Reales (double y float).

• Cadenas de caracteres (String).

1.8.1 Literales lógicos

Son únicamente dos, las palabras reservadas true y false.

Ejemplo: boolean activado = false;

1.8.2 Literales enteros

Los literales de tipo entero: byte, short, int y long pueden expresarse en decimal (base 10), octal (base 8) o hexadecimal (base 16). Además, puede añadirse al final del mismo la letra L para indicar que el entero es considerado como long (64bits).

En Java, el compilador identifica un entero decimal (base 10) al encontrar un número cuyo primer dígito es cualquier símbolo decimal excepto el cero (del 1 al 9). A continuación pueden aparecer dígitos del 0 al 9.

La letra L al final de un literal de tipo entero puede aplicarse a cualquier sistema de numeración e indica que el número decimal sea tratado como un entero largo (de 64 bits). Esta letra L puede ser mayúscula o minúscula, aunque es aconsejable utilizar la mayúscula ya que de lo contrario puede confundirse con el dígito uno (1) en los listados.

Ejemplo: long max1 = 9223372036854775807L; //valor máximo para un entero largo

1.8.3 Literales reales

Los literales de tipo real sirven para indicar valores float o double. A diferencia de los literales de tipo entero, no pueden expresarse en octal o hexadecimal.

Existen dos formatos de representación: mediante su parte entera, el punto decimal ( . ) y la parte fraccionaria; o mediante notación exponencial o científica:

Ejemplos equivalentes: 3.1415 0.31415e1 .31415e1 0.031415E+2 .031415e2 314.15e-2 31415E-4

Al igual que los literales que representan enteros, se puede poner una letra como sufijo. Esta letra puede ser una F o una D (mayúscula o minúscula indistintamente).

F --> Trata el literal como de tipo float.

D --> Trata el literal como de tipo double.

Ejemplo:

3.1415F

.031415d

1.8.4 Literales carácter

Los literales de tipo carácter se representan siempre entre comillas simples. Entre las comillas simples puede aparecer:

Un símbolo (letra) siempre que el carácter esté asociado a un código Unicode. Ejemplos: ‘a’ , ‘B’ , ‘{‘ , ‘ñ’ , ‘á’ .

Una “secuencia de escape”. Las secuencias de escape son combinaciones del símbolo contrabarra \ seguido de una letra, y sirven para representar caracteres que no tienen una equivalencia en forma de símbolo.

Las posibles secuencias de escape son:

\n -----> Nueva Linea.

\t -----> Tabulador.

\r -----> Retroceso de Carro.

\f -----> Comienzo de Pagina.

\b -----> Borrado a la Izquierda.

\\----> El carácter barra inversa ( \ ).

\' -----> El carácter prima simple ( ' ).

\" -----> El carácter prima doble o bi-prima ( " ).

Por ejemplo:

Para imprimir una diagonal inversa se utiliza: \\

Para imprimir comillas dobles en un String se utiliza: \"

1.8.5 Literales cadenas

Los Strings o cadenas de caracteres no forman parte de los tipos de datos elementales en Java, sino que son instanciados a partir de la clase java.lang.String, pero aceptan su inicialización a partir de literales de este tipo, por lo que se tratan en este punto.

⚠ Un literal de tipo string va encerrado entre comillas dobles ( “ ) y debe estar incluido completamente en una sola línea del programa fuente (no puede dividirse en varias líneas).

Entre las comillas dobles puede incluirse cualquier carácter del código Unicode (o su código precedido del carácter \ ) además de las secuencias de escape vistas anteriormente en los literales de tipo carácter.

Así, por ejemplo, para incluir un cambio de línea dentro de un literal de tipo string deberá hacerse mediante la secuencia de escape \n :

Ejemplo:

System.out.println(”Primera línea\nSegunda línea del string\n”);

System.out.println(”Hola”);

La visualización del string anterior mediante println() produciría la siguiente salida por pantalla:

Primera línea

Segunda línea del string

Hola

La forma de incluir los caracteres: comillas dobles ( “ ) y contrabarra ( \ ) es mediante las secuencias de escape \” y \\ respectivamente (o mediante su código Unicode precedido de \ ).

📣 Si el string es demasiado largo y debe dividirse en varias líneas en el fichero fuente, puede utilizarse el operador de concatenación de strings (+) de la siguiente forma:

”Este String es demasiado largo para estar en una línea del ” +

”fichero fuente y se ha dividido en dos.”

1.9 Salida y Entrada Estándar

1.9.1 Salida estándar

Ya hemos visto el uso de System.out para mostrar información por pantalla:

• print(“...”) imprime texto por pantalla

• println(“...”) imprime texto por pantalla e introduce un salto de línea.

La utilización de System.err sería totalmente análoga para enviar los mensajes producidos por errores en la ejecución (es el canal que usa también el compilador para notificar los errores encontrados).

Por ejemplo, para presentar el mensaje de saludo habitual por pantalla, y después un mensaje de error, tendríamos la siguiente clase (aunque en realidad toda la información va a la consola de comandos donde estamos ejecutando el programa):

xxxxxxxxxx
    public static void main(String[] args) {
        System.out.print("HOLA ");
        System.out.println("mundo");
        System.out.println("Mensaje de error");
    }

y la salida sería la siguiente:

También pueden imprimirse variables de cualquier tipo, así como combinaciones de texto y variables concatenadas con el operador +

xxxxxxxxxx
    public static void main(String[] args) {
        
        String nombre = "Pepito";
        int edad = 45;
      
        System.out.println(nombre);
        System.out.println(edad);
        System.out.println(nombre +" tiene "+edad+" años");
    }

Y la salida sería la siguiente:

1.9.2 Entrada estándar

La entrada estándar (leer información del teclado, escrita por el usuario) es un poco más compleja. Hay varias formas de hacerlo pero la más sencilla es utilizar la clase Scanner.

Siempre que queramos leer información del teclado primero tendremos que declarar un objeto Scanner que lea de la entrada estándar System.in así:

Scanner sc= new Scanner(System.in);

🧷 NOTA: En este ejemplo hemos creado un objeto Scanner llamado sc pero podríamos ponerle cualquier nombre.

Ahora podremos utilizar reader tantas veces como queramos para leer información del teclado. Por ejemplo:

String texto = sc.nextLine();

El método sc.nextLine() recogerá el texto que el usuario escriba por teclado (hasta presionar la tecla Intro) y lo guardará en texto (de tipo String).

Existen mucho otros métodos según el tipo de dato que se quiera leer:

• nextByte(): obtiene un número entero tipo byte.

• nextShort(): obtiene un número entero tipo short.

• nextInt(): obtiene un número entero tipo int.

• nextLong(): obtiene un número entero tipo long.

• nextFloat(): obtiene un número real float.

• nextDouble(): obtiene un número real double.

• next(): obtiene el siguiente token (texto hasta un espacio).

⚠ No existen métodos de la clase Scanner para obtener directamente booleanos ni para obtener un solo carácter.

📣 IMPORTANTE: Para poder utilizar la clase Scanner es necesario importarla desde el paquete java.util de Java. Es decir, arriba del todo (antes del public class… ) hay que escribir la siguiente sentencia:

import java.util.Scanner;

Ejemplo en el que leemos una cadena de texto y la mostramos por pantalla:

xxxxxxxxxx
package javaapplication1;
import java.util.Scanner;
/**
 *
 * @author Usuario
 */
public class JavaApplication1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        // TODO code application logic here
         String nombre;
        
        Scanner sc = new Scanner(System.in);
        
        System.out.println("Introduce tu nombre: ");
        
        nombre = sc.nextLine();
        
        System.out.println("Hola " + nombre);
    }
    
}

Salida:

Ejemplo en el que leemos un valor tipo double. El programa pide al usuario que introduzca el radio de un círculo, luego calcula su área y circunferencia, por último lo muestra por pantalla.

xxxxxxxxxx
import java.util.Scanner;
/**
 *
 * @author Usuario
 */
public class JavaApplication1 {

    public static void main(String[] args) {
        
        
        double radio, area, circumferencia;
        
        Scanner sc = new Scanner(System.in);
        
        System.out.println("Introduce el radio: ");
        
        radio = sc.nextDouble();
        
        // Se hace uso de la libreria Math para hacer uso de PI y la potencia (pow)
        
        area = Math.PI * Math.pow(radio, 2);
        
        circumferencia = 2 * Math.PI * radio;
              
        System.out.println("El area es " + area);
        
        System.out.println("La circumferencia es " + circumferencia);
    }
    
}

Salida:

1.10 Strings (cadenas de caracteres)

Hasta ahora hemos trabajado con el tipo de dato String el cual nos permite almacenar una cadena de caracteres. Para poder trabajar con String disponemos de una serie de funciones que nos van a ayudar a trabajar con ellos.

• Se concatenan con el +

• Se obtiene el tamaño de la cadena con length()

• Se accede a una letra con charAt(posicion) (recuerda, en Java la primera posición de un String o un array es la 0)

• Se busca la posición de un texto dentro de otro con indexOf()

• Se mira si un texto contiene otro con contains()

  • Otras opciones: startsWith(), endsWith()

• Se pasa a mayúsculas con toUpperCase(), y a minúsculas con toLowerCase()

• Se reemplaza un texto por otro con replace()

• Se obtiene una subcadena con substring(). Se indica desde dónde cortar (inclusive) y hasta dónde (exclusive)

• Se parte una cadena por un delimitador con split()

• Se compara para ver si son iguales con equals(...) NO CON (==), y alfabéticamente con compareTo()

Aquí podemos ver una serie de ejemplos de estos, comentado al lado de cada uno de ellos podéis ver el resultado:

xxxxxxxxxx
public class Main {

    public static void main(String[] args) {
    String texto1 = "Hola", texto2="buenas";

        String texto = texto1 +" " + texto2; // "Hola buenas"
        char letra = texto.charAt(5); //'b'
        int tamanyo = texto.length(); // 11
        int posicion1 = texto.indexOf("buenas"); //5
        int posicion2 = texto.indexOf("aaa"); // -1 No encontrado
        boolean existe = texto.contains("bue"); // true
        boolean termina = texto.endsWith("nas"); // true
        String mayusculas = texto.toUpperCase();// "HOLA BUENAS"
        String textoR = texto.replace("bu", "BU"); // "Hola BUenas"
        String subcad = texto.substring(2,4); // "la"
        String[] partes = texto.split(" ");  // {"Hola", "buenas"}
        boolean igual = texto1.equals("Hola"); // true
        int resultado = texto.compareTo("Adios"); // número > 0
    }
}

2. El Lenguaje Dart

Dart (originalmente llamado Dash) es un lenguaje de programación de código abierto, desarrollado por Google. Fue revelado en la conferencia goto; en Aarhus, Dinamarca el 10 de octubre de 2011.2 El objetivo de Dart no es reemplazar JavaScript como el principal lenguaje de programación web en los navegadores web, sino ofrecer una alternativa más moderna. El espíritu del lenguaje puede verse reflejado en las declaraciones de Lars Bak, ingeniero de software de Google, que define a Dart como un “lenguaje estructurado pero flexible para programación Web”.

2.1 Primer ejemplo

Como se puede observar, la entrada al programa principal en dart se realiza también a través del método main de tipo void.

xxxxxxxxxx
void main() {
  print('Hello, World!');
}

2.2 Elementos básicos

2.2.1. Comentarios

Al igual que en Java los comentarios en Dart se realizan de igual forma:

xxxxxxxxxx
// Este es un comentario normal de una sola línea.

/// Este es un comentario de documentación, utilizado para documentar bibliotecas,
/// clases y sus miembros. Herramientas como IDE y dartdoc tratan
/// los comentarios de documentación de manera especial.

/* También se admiten comentarios como estos. */

2.2.2 Identificadores

Las reglas para el nombrado de variables son las siguientes:

• Debe estar formado por caracteres alfanuméricos, aunque no puede comenzar por un carácter numérico.

• No puede contener espacios.

• Sólo puede contener los símbolos _ y $.

• No pueden utilizarse palabras reservadas del lenguaje.

• Dart es sensible a mayúsculas y minúsculas (case sensitive).

2.3 Tipos de datos

El lenguaje Dart tiene soporte especial para lo siguiente:

• Numbers (int, double)

• Strings (String)

• Booleans (bool)

• Records ((value1, value2))

• Lists (List, También conocida como matrices)

• Sets (Set)

• Maps (Map)

• Runes (Runes; A menudo reemplazada por la API de caracteres)

• Symbols (Symbol)

• The value null (Null)

Números

https://dart.dev/language/built-in-types#numbers

Los números de Dart vienen en dos tipos:

• int

  Los valores enteros no superan los 64 bits, dependiendo de la plataforma. En plataformas nativas, los valores pueden ser de -2 63 a 2 63 63 - 1. En la web, los valores enteros se representan como números de JavaScript (valores de 64 bits de punto flotante sin parte fraccionada) y pueden ser de -2 53 a 2 53 - 1.

• double

  números flotantes de 64 bits (de doble precisión), según lo especificado por la norma IEEE 754.

Ambos inty doubleson subtipos de num. El tipo num incluye operadores básicos tales como el de los operadores, -, /, y *, y también es donde encontrará abs(),ceil(), y floor(), entre otros métodos. (Los operadores de apto, como el de la intclase.) Si num y sus subtipos no tienen lo que estás buscando, la biblioteca de dardos:math podría.

A continuación, se muestran algunos ejemplos de definición:

xxxxxxxxxx
void main() {
    double nota_media = 7.25;
    int num_alumnos = 22;
    print(nota_media);
    print(num_alumnos);
}

Cadenas

El tipo para declarar variables que puedan contener cadenas de texto es String [ver documentación]. Estas pueden ir encerradas entre comillas simples o entre comillas dobles:

xxxxxxxxxx
void main() {
    String cadena1, cadena2;
    cadena1 = "Esto es una cadena de texto";
    cadena2 = 'Esto es también una cadena de texto';
    print(cadena1);
    print(cadena2);
}

2.4 Declaración de variables

Para declarar una variable en Dart, la sintaxis básica es: Tipo nombre_variable [= valor]; Se pueden declarar varias variables en la misma línea con la siguiente sintaxis: Tipo nombre_variable1 [[=valor1][, nombre_variable2 [=valor2]…]; Puedes copiar el siguiente código en DartPad para comprobar el funcionamiento (en próximos apartados se estudiarán los tipos permitidos en Dart):

xxxxxxxxxx
void main() {
    int alu_grupo_A = 22, alu_grupo_B = 25;
    int alu_grupo_C;
    alu_grupo_C = 21;
    print(alu_grupo_A);
    print(alu_grupo_B);
    print(alu_grupo_C);
}

Tipado débil

Las variables que hemos explicado anteriormente utilizan un tipo en la declaración que define su dominio, pero puede haber casos muy concretos en los que no sepamos qué tipo de dato va a recibir una función, por ejemplo, a la hora de consumir una API. Para estos casos, tenemos dos opciones:

1. Declarar la variable con el tipo var:

   xxxxxxxxxx
   void main() {
       var debil = 5;
       print(debil.runtimeType);
       debil = 'hola';
   }
   

   El programa nos debe mostrar que el tipo de la variable es int, porque al asignar el valor en la declaración, el tipo cambia al del valor asignado. En realidad, nos dará error porque al asignarse el tipo int, estamos incurriendo en un error al intentar asignarle un String.

   Si el valor es asignado después de la declaración, podemos asignar valores de diferentes tipos a lo largo de la ejecución del programa y en cada momento cambiará el tipo de la variable:

   xxxxxxxxxx
   void main() {
       var debil;
       print(debil.runtimeType);
       debil = 'hola';
       print(debil.runtimeType);
       debil = 5;
       print(debil.runtimeType);
   }
   

   En el caso anterior mostrará: null String int

2. Declarar la variable como dynamic:

   xxxxxxxxxx
   void main() {
       dynamic debil;
       debil = 'hola';
       print(debil.startsWith('h'));
   }
   

   Tiene exactamente el mismo funcionamiento que utilizar var sin asignar el valor en la declaración. Tanto si utilizamos var como dynamic, podemos utilizar métodos y propiedades del tipo en tiempo de ejecución de la variable, tal y como se puede comprobar ejecutando el código del último ejemplo, donde se invoca al método startsWith(…) del tipo String.

Nullables

A partir de la versión 2.19 de Dart, se introdujo una característica existente en otros lenguajes y que evita algunos errores en tiempo de ejecución. Esta característica son las variables Nullables o que tienen la capacidad de aceptar valores nulos. El siguiente ejemplo, en el que se suman dos valores enteros es, para una versión de Dart sin comprobación de nulos, correcto y se compila sin errores:

xxxxxxxxxx
void main(List<String> arguments) {
    int operando1=5, operando2, suma;
    suma = operando1 + operando2;
    print(suma);
}

¿Cuál es el problema? Al intentar sumar la variable operando2, con valor nulo, a la variable operando1, se produce un error de ejecución. En las versiones actuales, por defecto, las variables no permiten valores nulos, y es preciso asignarles valor en algún punto del programa para que nos permita compilarlo.

Para poder declarar variables que acepten valores nulos, es necesario hacerlo de forma explicita mediante el operador ?. Esto sería válido, por ejemplo, para poder asignar a una variable el valor de una función que pueda devolver null.

xxxxxxxxxx
void main(List<String> arguments) {
    int? operando1, operando2 = 10;
    print(operando1);
    print(operando2);
}

Operador de aserción !

En determinadas ocasiones querremos asignar el resultado de expresiones a una variable no nullable, pero el compilador, al no ser capaz de prever si el valor de la expresión es o no nulo, arroja un error de compilación aunque nuestro código sea correcto y hayamos creado la expresión de forma que siempre devuelva un valor no nulo:

xxxxxxxxxx
void main() {
    int valor1=5, valor2=8, max;
    max=maximo(valor1, valor2);
    print(max);
}
//Función que devuelve el máximo de dos números
int? maximo(int num1, num2) {
    if(num1>num2)
    return num1;
    else
    return num2;
}

En el ejemplo anterior, al ser el tipo de devolución de la función maximo un valor entero nullable, en el que la función podría devolver un nulo, el compilador detectará un error semántico al asignar el valor de retorno a una variable no nullable, y abortará la ejecución a pesar de que la función nunca devolverá null. La forma de evitar esto en expresiones en las que estamos seguros de que se devuelve un valor correcto es añadiendo un operador de aserción (carácter !) tras la expresión:

xxxxxxxxxx
max=maximo(valor1, valor2)!;

2.4.1 Declaración de constantes

Para declarar valores que no van a cambiar durante la ejecución del programa, Dart utiliza las palabras reservadas const y final, que funcionan de la misma manera en el caso de los tipos simples.

xxxxxxxxxx
void main() {
    final int NUM_ALU = 25;
    print(NUM_ALU);
}

xxxxxxxxxx
void main() {
    const int NUM_ALU = 25;
    print(NUM_ALU);
}

Por convención, las constantes suelen escribirse en mayúsculas, aunque no es una norma del lenguaje. El tipo no es obligatorio ponerlo, aunque sí aconsejable.

2.5 Concatenación

Para concatenar cadenas de texto, Dart nos ofrece tres mecanismos:

Mediante operador +: concatena dos cadenas. A diferencia de otros lenguajes en los que se pueden concatenar expresiones de cadena con otras de tipos diferentes, en Dart únicamente se permite concatenar String, teniendo que hacer un casting (toString()) para concatenar tipos diferentes:

xxxxxxxxxx
void main() {
    String hola = "Hola", mundo = "mundo";
    print(hola + " " + mundo);
}

Mediante interpolación de cadenas: Anteponiendo el símbolo de dólar al nombre de la variable o constante dentro de la cadena($variable). En este caso, el tipo de la variable sí puede ser diferente de String:

xxxxxxxxxx
void main() {
    int num = 5;
    print("El valor de la variable es $num");
}

Encerrando la expresión entre llaves y anteponiendo el símbolo de dólar (${expresión}):

xxxxxxxxxx
void main() {
    String cadena = "Esto es una cadena de texto";
    print("Contiene 'cad': ${cadena.contains('cad')}");
    print("Cadena pasada a mayúsculas: ${cadena.toUpperCase()}");
    print("Longitud: ${cadena.length}");
}

2.6 Operadores

2.6.1 Operadores aritméticos

Para realizar operaciones de tipo aritmético, Dart utiliza los mismos operadores que C o Java:

• +: suma de dos valores o variables de tipo numérico.

• -: resta de dos valores o variables de tipo numérico

• *: producto de dos valores o variables de tipo numérico

• /: división de dos valores o variables de tipo numérico. A diferencia de C, Java, etc., donde el resultado de dos dividir dos variables de tipo entero era otro valor entero (división entera), en el caso de Dart el resultado es entero si la división es exacta y double en caso contrario.

• ~/: división entera.

• %: Módulo o resto

• Operadores abreviados: son abreviaturas de las operaciones anteriores que asignan a la variable en la parte izquierda de la igualdad el resultado de variable_izquierda operador expresión_derecha. Ejemplo:

  xxxxxxxxxx
  int x = 5, y = 6;
  x += y; //es equivalente a x=x+y;
  

• ++: Incremento. Si se pone antes de la variable en una expresión, en primer lugar, se ejecuta el incremento y después la expresión con el valor incrementado. Si se pone después de la variable, se ejecuta la expresión, con el valor sin incrementar y, a continuación, el incremento.

• --: Decremento. Similar al incremento, pero haciendo la resta.

xxxxxxxxxx
void main() {
    var a=8;
    var b=3;
    print("Suma $a + $b: ${a+b}"); //Suma a + b
    print("Resta $a - $b: ${a-b}"); //Resta a - b
    print("Producto $a * $b: ${a*b}"); //Multiplica a * b
    print("División real $a / $b: ${a/b}"); //Divide a / b
    print("División entera $a ~/ $b: ${a~/b}"); //Divide a / b
    print("División entera $a / $b: ${(a/b).truncate()}"); //Divide a / b
    print("Módulo $a / $b: ${a%b}"); //Resto de a / b
    a=b;
    print("Suma $a + $b: $a"); //a = a + b
    a-=b;
    print("Resta $a - $b: $a"); //a = a - b
    a*=b;
    print("Producto $a * $b: $a"); //a = a * b
    // a/=b;
    print("División $a / $b: $a"); //a = a / b
    a%=b;
    print("Módulo $a / $b: $a"); //a = a % b
    print("Postincremento ${b++}"); //Muestra 3, aunque b se incrementa
    //después
    print("Preincremento ${++b}"); //Muestra 5, porque b=4 y se incrementa
    //antes de mostrar el valor
    print("Postdecremento ${b--}"); //Muestra 5, aunque b se decrementa
    //después
    print("Preincremento ${--b}"); //Muestra 4, porque b=5 y se decrementa
    //antes de mostrar el valor
}

La operación a/=b se ha comentado porque al devolver a/b un valor double, genera un error cuando se intenta asignar a la variable a, que es int. Si a y b estuviesen declaradas como double, la operación sería correcta.

2.6.2 Operadores relacionales

Son los operadores que vamos a utilizar para realizar comparaciones:

xxxxxxxxxx
==: es igual
!=: es diferente
>: Mayor que
<: Menor que
>=: Mayor o igual que
<=: Menor o igual que

A la hora de comparar objetos, si se quiere averiguar si dos instancias son el mismo objeto, se utiliza el método identical() en lugar de ==.

2.6.3 Operadores lógicos

Los operadores lógicos son los mismos que en C:

• &&: and (y).

• ||: or (o).

• !: not (negación).

2.7 Conversión de tipos (Casting)

Hacer un casting a un dato, consiste en hacer una conversión de su tipo para convertirlo en otro diferente. A diferencia de lo que ocurre en otros lenguajes, en Dart no existe la conversión implícita. Teniendo que indicar de forma explícita el tipo al que queremos convertir. Por ejemplo, no es posible concatenar una variable numérica a una cadena, como se muestra en el siguiente ejemplo en Java:

xxxxxxxxxx
int n = 5;
print("Valor de n: " + n);

O asignar un valor de un tipo diferente a una variable como podríamos hacer en C:

xxxxxxxxxx
int i=5;
float f=i;
printf(“Valor de f: %f”, f); //mostraría Valor de f: 5.000000

Para poder llevar a cabo las conversiones en Dart, podremos hacerlo de tres formas diferentes:

1. Utilizando un método del dato que nos permita convertir al tipo deseado. El siguiente ejemplo, que utiliza el método toString() [ver documentación], es equivalente al ejemplo mostrado en Java:

   xxxxxxxxxx
   int n = 5;
   print("Valor de n: " + n.toString()); //convierte n a String
   

   El siguiente ejemplo, que utiliza el método toDouble() [ver documentación], es equivalente al código en C:

   xxxxxxxxxx
   int i = 5;
   double f = i.toDouble();
   print("Valor de f: ${f}"); //mostraría Valor de f: 5.0
   

2. Utilizando la función estática parse(String) [ver documentación], propia del tipo para parsear (convertir) un String al dato, previo análisis para comprobar que el formato es válido. Si queremos convertir, por ejemplo, un int a double, utilizamos el método desde el tipo double, convirtiendo el int a String, como se muestra en el siguiente ejemplo equivalente al código C:

   xxxxxxxxxx
   int i = 5;
   double f = double.parse(i.toString());
   print("Valor de f: ${f}"); //mostraría Valor de f: 5.0
   

   El tipo String no tiene método parse, porque la conversión se hace utilizando el método toString() del dato.

3. Utilizando el método tryParse(String) [ver documentación], que funciona como la anterior, pero en lugar de lanzar una excepción si se le pasa un parámetro incorrecto, devuelve null. Se puede combinar con el operador ?? que se estudiará en el apartado de expresiones condicionales.

2.8 Entrada y salida estándar

La entrada y salida estándar en dart, al igual que en cualquier lenguaje, es dependiente del sistema operativo y para nuestro caso la entrada es por teclado y la salida por pantalla.

Para la salida, ya hemos visto cual es el método que nos es necesario, print, en ejemplos anteriores.

Para la entrada lo recogemos con el método stdin.readLineSync() que por defecto recoge una cadena de texto desde el teclado. Si luego necesitamos que sea un entero, deberemos parsearlo.

xxxxxxxxxx
import 'dart:io';

void main() {
  print('Ingresa un número entero:');
  
  // Leer la entrada del usuario como cadena
  String? entrada = stdin.readLineSync();
  
  // Convertir la cadena a entero si no es nula y la conversión es válida
  if (entrada != null) {
    try {
      int numero = int.parse(entrada);
      print('El número que ingresaste es: $numero');
    } catch (e) {
      print('Por favor, ingresa un número entero válido.');
    }
  } else {
    print('No ingresaste ningún valor.');
  }
}